{"cells":[{"cell_type":"markdown","metadata":{"id":"zfqERVVKxIU0"},"source":["# Implement RNN unfolding using RNNCell and LSTMCell\n","\n","<br>\n","<font color='#2c3e50'>\n","    \n","- RNN, LSTM and GRU cells can be seen as neural networks that process each step of the input time-series (in somewhat recursive manner). This is often referred to as `unrolling or unfolding of RNN`.\n","- LSTM/RNN/GRU layers provide an abstraction over this operation.\n","</font>\n","\n","## 1. Task:\n","\n","<font color='red'>\n","\n","<b>In this lab exercise, you have to implement `unfolding or unrolling` using `RNNCell` and `LSTMCell`. </b> \n","</font>\n","\n","\n","<font color='#2c3e50'>  \n","<ul>    \n","<li>\n","\n","RNNCell (or LSTMCell) takes a feature vector and hidden state (or hidden and cell state) at a time-step and outputs the updated hidden state (or hidden and cell states). The hidden state obtained after the last time-step is considered as a latent representation of the time-series and is given as input to the dense or classification layer(s). </li>   \n","    \n","<li>\n","    \n","This notebook contains two PyTorch model definitions (i.e. `LSTMClassifier` and `RNNClassifier`) and `trainer()` function to process the training data and train models. The entire code is in `almost` working condition. You need to complete the `forward()` function in both `LSTMClassifier` and `RNNClassifier` classes. In essence, you need to implement RNN unrolling in `forward()`. </li>   \n","\n","    \n","<li>\n","    \n","If you are not comfortable with PyTorch, please see the Reference notebook. It summarises how to define and train a model in modular manner. </li>\n","    \n","\n","<li> \n","    \n","Since RNN cells are essentially composed of standard dense or linear layers, you are welcome to implement your own RNNCell instead of using the implemented one.  \n","    \n","    \n","</ul>\n","</font>\n","    \n"," \n","### 1.1 HINTS:\n","<br>\n","<font color='#2c3e50'>  \n","<ul>    \n","<li>\n","    \n","Run a loop over time-steps </li>\n","\n","<li>\n","    \n","Neural network process one batch at a time. So, input to `RNNCell` at each time-step is `(batch_size,n_features)`</li>    \n","</ul>\n","</font>\n","\n","### 1.2 Instructions:\n","\n","- You have to implement `forward functions` in both `LSTMClassifier` and `RNNClassifier` classes. \n","- These functions take a batch of time-series of size `(batch_size,n_steps,n_features)` and output mortality predictions (1/0 binary predictions) of shape `(batch_size,1)`.\n","\n","\n","### 1.3 Data:\n","\n","- Physionet 2012: Mortality prediction (discussed yesterday)\n","- Each time-series consists of K-dimenional vector (`n_features=K`) at 48 time-steps (`n_steps=48`). `Size of each time-series : (48,K)`\n"]},{"cell_type":"markdown","metadata":{},"source":[]},{"cell_type":"markdown","metadata":{"id":"hdc1v7fvxIU5"},"source":["## 2. Synatx of RNNCell and LSTMCell\n","\n","\n","### 2.1 RNNCell:\n","\n","\n","#### PyTorch syntax:\n","<img src=\"./img/rnn_cell_1.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","<img src=\"./img/rnn_cell_2.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","<img src=\"./img/rnn_cell_3.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","<img src=\"./img/rnn_cell_4.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","<img src=\"./img/rnn_cell_5.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","\n","### 2.2 LSTMCell\n","\n","#### PyTorch syntax:\n","<img src=\"./img/lstm_cell_1.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","<img src=\"./img/lstm_cell_2.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","<img src=\"./img/lstm_cell_3.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","<img src=\"./img/lstm_cell_4.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n","\n","\n","\n","### 2.3 More information at:\n","\n","- http://pytorch.org/docs/stable/generated/torch.nn.LSTMCell.html\n","- http://pytorch.org/docs/stable/generated/torch.nn.RNNCell.html"]},{"cell_type":"markdown","metadata":{"id":"sw9jhQgQxIU6"},"source":["## Implementation Begins:"]},{"cell_type":"code","execution_count":1,"metadata":{"executionInfo":{"elapsed":1188,"status":"ok","timestamp":1636212379714,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"8Ust8VKMxIU7"},"outputs":[],"source":["import torch\n","from torch import nn\n","from torch.nn import functional as F\n","from tqdm import tqdm\n","import numpy as np\n","from sklearn.metrics import roc_auc_score\n","from utils import get_validation_score\n","import warnings\n","warnings.filterwarnings('ignore')\n","import matplotlib.pyplot as plt"]},{"cell_type":"code","execution_count":2,"metadata":{"executionInfo":{"elapsed":14,"status":"ok","timestamp":1636212379715,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"f39vXbYTxIU9"},"outputs":[],"source":["class RNNClassifier(nn.Module):\n","    \n","    def __init__(self, input_dim, hidden_dim,device):\n","        super().__init__()\n","        self.hidden_dim = hidden_dim\n","        self.rnn = nn.RNNCell(input_dim, hidden_dim)  # RNN Cell\n","        self.fc = nn.Linear(hidden_dim, 1)            # fully connected layer: maps last hidden vector to model prediction\n","        self.activation = nn.Sigmoid()                # coz binary classification\n","        self.device=device\n","    \n","    def forward(self, x):\n","\n","        hidden = self.init_hidden(x)\n","        \n","        ############################# \n","        \n","        # Write you code here.\n","        # Return expects variable out. Its the hidden vector obtained after last time-step.\n","        \n","        time_steps=x.shape[1]                 # shape of x is (batches,time_Steps,features)\n","        \n","        for i in range(0,time_steps):\n","            inputs=x[:,i]                     # (batch,features) shape\n","            hidden = self.rnn(inputs,hidden)\n","            \n","        out = self.fc(hidden)                 # take the hidden vector corresponding to last time step\n","        ###########################\n","        \n","        return self.activation(out)\n","    \n","    def init_hidden(self, x):\n","        h0 = torch.zeros(x.size(0), self.hidden_dim)\n","        return h0.to(self.device)"]},{"cell_type":"code","execution_count":3,"metadata":{"executionInfo":{"elapsed":13,"status":"ok","timestamp":1636212379716,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"ikvKS54axIU-"},"outputs":[],"source":["class LSTMClassifier(nn.Module):\n","    \n","    def __init__(self, input_dim, hidden_dim,device):\n","        super().__init__()\n","        self.hidden_dim = hidden_dim\n","        self.rnn = nn.LSTMCell(input_dim, hidden_dim)\n","        self.fc = nn.Linear(hidden_dim, 1)\n","        self.activation = nn.Sigmoid()\n","        self.device=device\n","    \n","    def forward(self, x):\n","        hidden,cell = self.init_hidden(x)\n","        \n","        ############################\n","        \n","        # Write you code here.\n","        # Resturn expects variable out. Its the hidden vector obtained after last time-step.\n","        \n","        \n","        time_steps=x.shape[1]              #shape of x is (batches,time_Steps,features)\n","        \n","        for i in range(0,time_steps):\n","            inputs=x[:,i]                  # (batch,features) shape\n","            hidden,cell = self.rnn(inputs,(hidden,cell))\n","        \n","        out = self.fc(hidden)              # take the hidden vector corresponding to last time step\n","        #############################\n","        \n","        return self.activation(out)\n","    \n","    def init_hidden(self, x):\n","        h0 = torch.zeros(x.size(0), self.hidden_dim)\n","        c0 = torch.zeros(x.size(0), self.hidden_dim)\n","        return h0.to(self.device),c0.to(self.device)"]},{"cell_type":"code","execution_count":4,"metadata":{"executionInfo":{"elapsed":13,"status":"ok","timestamp":1636212379717,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"Pdk6nqo8xIU-"},"outputs":[],"source":["# Function to compute validation score: Used in trainer()\n","\n","def get_validation_score(model,Val_T,Val_L):\n","    model.eval()\n","    tensor_x = torch.Tensor(Val_T).to(model.device)\n","    preds=model(tensor_x)[:,0]\n","    LOSS=nn.BCELoss().to(device)\n","    val_loss=LOSS(preds,torch.Tensor(Val_L).type(torch.FloatTensor).to(model.device))\n","    return roc_auc_score(Val_L, preds.cpu().detach().numpy()), val_loss"]},{"cell_type":"code","execution_count":5,"metadata":{"executionInfo":{"elapsed":13,"status":"ok","timestamp":1636212379718,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"qjKFBLTyxIU_"},"outputs":[],"source":["def trainer(model,training_set,validation_set,device,lr,stored_name,epochs=10):\n","    \n","    # Recieves data and labels \n","    T,L=training_set \n","    Val_T,Val_L=validation_set\n","    \n","    # intialise optimiser and criterion\n","    \n","    optimizer_model = torch.optim.SGD(model.parameters(),lr,momentum=0.9, nesterov=True)\n","    criterion = nn.BCELoss().to(device)\n","\n","    # \n","    best=0\n","    LOSS=[]\n","    VAL_LOSS=[]\n","    \n","    # training begins\n","    \n","    for epoch in range(0,epochs):\n","        Loss=0\n","        model.train()\n","        for k in range(0,len(T)):\n","            \n","            inputs=T[k]\n","            labels=L[k]\n","            \n","            inputs=torch.Tensor(inputs).to(device)\n","            labels=torch.Tensor(labels).type(torch.FloatTensor).to(device)\n","            \n","            pred=model(inputs)\n","            \n","            loss=criterion(pred[:,0],labels)\n","            optimizer_model.zero_grad()\n","            loss.backward()\n","            optimizer_model.step()\n","            Loss=Loss+loss\n","           \n","        Val_ROC,val_loss=get_validation_score(model,Val_T,Val_L)\n","        VAL_LOSS.append(val_loss.detach().cpu().numpy())\n","        LOSS.append((Loss/len(T)).detach().cpu().numpy())\n","        \n","        print(' Epoch: {:.1f} Training Loss {:5f} Validation Loss {:.4f} Validation AUC {:.5f}'.format(epoch,LOSS[-1],VAL_LOSS[-1],Val_ROC))\n","        \n","        # If current validation score is greater than best, store the model\n","        \n","        if best<Val_ROC:\n","           torch.save(model, './'+stored_name) \n","\n","    return torch.load('./'+stored_name).to(device),LOSS,VAL_LOSS     "]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":845,"status":"ok","timestamp":1636212380550,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"8itcyfT3xIVA","outputId":"a8415f54-8b80-4f65-c715-a0d00320c399"},"outputs":[{"name":"stdout","output_type":"stream","text":["(33, 48, 59)\n"]}],"source":["# Get training and validation data\n","\n","from get_data import get_training_data,get_validation_data\n","\n","T,L=get_training_data(batch_size=32)  # returns lists of training data and label batches\n","Val_T,Val_L=get_validation_data()     # numpy arrays of validation data and labels\n","\n","print(T[0].shape)                     # (batch_size,time_steps,n_features)"]},{"cell_type":"code","execution_count":7,"metadata":{"executionInfo":{"elapsed":13,"status":"ok","timestamp":1636212380551,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"y43nY3esxIVC"},"outputs":[],"source":["device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"]},{"cell_type":"code","execution_count":8,"metadata":{"executionInfo":{"elapsed":12,"status":"ok","timestamp":1636212380552,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"wrOne0ySxIVC"},"outputs":[],"source":["n_features=T[0].shape[2]     # 76 dimensional vector at each time step\n","recurrent_units=128          # number of hidden units in  a RNN/LSTM\n","lr=0.001                     # learning rate "]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"collapsed":true,"executionInfo":{"elapsed":13,"status":"ok","timestamp":1636212380553,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"NnxeESThxIVD","outputId":"69d9927a-96aa-49ef-e904-e980717c0396"},"outputs":[{"name":"stdout","output_type":"stream","text":["LSTMClassifier(\n","  (rnn): LSTMCell(59, 128)\n","  (fc): Linear(in_features=128, out_features=1, bias=True)\n","  (activation): Sigmoid()\n",")\n"]}],"source":["# Create LSTMClassifier model object\n","\n","model=LSTMClassifier(n_features,recurrent_units,device)\n","print(model)"]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":82127,"status":"ok","timestamp":1636212462671,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"dGsbdDO9xIVD","outputId":"9910184d-d6d3-4703-bda4-dfc8e44f0eda"},"outputs":[{"name":"stdout","output_type":"stream","text":[" Epoch: 0.0 Training Loss 0.557765 Validation Loss 0.4724 Validation AUC 0.66292\n"," Epoch: 1.0 Training Loss 0.448890 Validation Loss 0.4408 Validation AUC 0.71244\n"," Epoch: 2.0 Training Loss 0.431052 Validation Loss 0.4301 Validation AUC 0.74600\n"," Epoch: 3.0 Training Loss 0.419855 Validation Loss 0.4194 Validation AUC 0.76830\n"," Epoch: 4.0 Training Loss 0.408042 Validation Loss 0.4079 Validation AUC 0.78226\n"," Epoch: 5.0 Training Loss 0.395625 Validation Loss 0.3963 Validation AUC 0.79053\n"," Epoch: 6.0 Training Loss 0.383454 Validation Loss 0.3856 Validation AUC 0.79572\n"," Epoch: 7.0 Training Loss 0.372733 Validation Loss 0.3771 Validation AUC 0.79934\n"," Epoch: 8.0 Training Loss 0.364477 Validation Loss 0.3714 Validation AUC 0.80212\n"," Epoch: 9.0 Training Loss 0.358903 Validation Loss 0.3682 Validation AUC 0.80444\n"]}],"source":["# Train LSTMClassifier\n","\n","model=model.to(device)\n","model, training_loss, validation_loss=trainer(model,(T,L),(Val_T,Val_L),device,lr,stored_name='lstm',epochs=10)"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":391},"executionInfo":{"elapsed":404,"status":"ok","timestamp":1636212463051,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"dNz56XhfxIVE","outputId":"96fea02f-60c8-47db-afe0-0571394183d8"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 500x500 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# Plot training and validation loss\n","import matplotlib.pyplot as plt\n","\n","fig, ax = plt.subplots(figsize=(5,5))\n","\n","lw = 2\n","\n","plt.tight_layout()\n","ax.plot(np.linspace(1, len(training_loss), num=len(training_loss)),training_loss, color='rebeccapurple',\n","         lw=2, linestyle='-', label='Training Loss')\n","\n","ax.plot(np.linspace(1, len(training_loss), num=len(training_loss)),validation_loss, color='r',\n","         lw=2, linestyle='-', label='Validation_loss')\n","\n","ax.set_xlabel('# Epochs',fontsize=14)\n","ax.set_ylabel('# Loss',fontsize=14)\n","ax.legend(loc=\"best\",fontsize=12)\n","\n","ax.tick_params(axis='x', labelsize=13)\n","ax.tick_params(axis='y', labelsize=13)\n","\n","\n","plt.grid(color='gray', linestyle='-', linewidth=0.1)\n","\n","\n","plt.show()"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"collapsed":true,"executionInfo":{"elapsed":24,"status":"ok","timestamp":1636212463052,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"hDbJz7X5xIVE","outputId":"f3f93b10-2890-4cb6-87f6-6444f86b35b4"},"outputs":[{"name":"stdout","output_type":"stream","text":["RNNClassifier(\n","  (rnn): RNNCell(59, 128)\n","  (fc): Linear(in_features=128, out_features=1, bias=True)\n","  (activation): Sigmoid()\n",")\n"]}],"source":["# Create RNNClassifier model object\n","\n","model=RNNClassifier(n_features,recurrent_units,device)\n","print(model)\n"]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":25245,"status":"ok","timestamp":1636212488277,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"rfH4BX_TxIVE","outputId":"61f99dbe-2714-4dee-f0fa-f13185452959"},"outputs":[{"name":"stdout","output_type":"stream","text":[" Epoch: 0.0 Training Loss 0.461752 Validation Loss 0.4137 Validation AUC 0.76795\n"," Epoch: 1.0 Training Loss 0.377099 Validation Loss 0.3698 Validation AUC 0.80352\n"," Epoch: 2.0 Training Loss 0.353274 Validation Loss 0.3676 Validation AUC 0.80792\n"," Epoch: 3.0 Training Loss 0.350327 Validation Loss 0.3660 Validation AUC 0.81007\n"," Epoch: 4.0 Training Loss 0.348616 Validation Loss 0.3649 Validation AUC 0.81140\n"," Epoch: 5.0 Training Loss 0.347329 Validation Loss 0.3641 Validation AUC 0.81251\n"," Epoch: 6.0 Training Loss 0.346274 Validation Loss 0.3635 Validation AUC 0.81337\n"," Epoch: 7.0 Training Loss 0.345370 Validation Loss 0.3629 Validation AUC 0.81418\n"," Epoch: 8.0 Training Loss 0.344571 Validation Loss 0.3624 Validation AUC 0.81498\n"," Epoch: 9.0 Training Loss 0.343848 Validation Loss 0.3620 Validation AUC 0.81571\n"]}],"source":["# Train RNNClassifier\n","\n","model=model.to(device)\n","model, training_loss, validation_loss=trainer(model,(T,L),(Val_T,Val_L),device,lr,stored_name='rnn',epochs=10)"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":386},"executionInfo":{"elapsed":19,"status":"ok","timestamp":1636212488279,"user":{"displayName":"Anshul Thakur","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"11719449395424920327"},"user_tz":0},"id":"Mu9R8dUAxIVF","outputId":"88a70b17-dff8-4eed-abd5-eaf2b9503f95"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 500x500 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# Plot training and validation loss\n","\n","fig, ax = plt.subplots(figsize=(5,5))\n","\n","lw = 2\n","\n","plt.tight_layout()\n","ax.plot(np.linspace(1, len(training_loss), num=len(training_loss)),training_loss, color='rebeccapurple',\n","         lw=2, linestyle='-', label='Training Loss')\n","\n","ax.plot(np.linspace(1, len(training_loss), num=len(training_loss)),validation_loss, color='r',\n","         lw=2, linestyle='-', label='Validation_loss')\n","\n","ax.set_xlabel('# Epochs',fontsize=14)\n","ax.set_ylabel('# Loss',fontsize=14)\n","ax.legend(loc=\"best\",fontsize=12)\n","\n","ax.tick_params(axis='x', labelsize=13)\n","ax.tick_params(axis='y', labelsize=13)\n","\n","\n","plt.grid(color='gray', linestyle='-', linewidth=0.1)\n","\n","\n","#plt.savefig('./loss_curves.pdf',dpi=100,bbox_inches='tight')\n","plt.show()"]}],"metadata":{"colab":{"name":"Problem 1  with solution.ipynb","provenance":[]},"kernelspec":{"display_name":"Python 3.9.7 ('ml4timeseries')","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.17"},"vscode":{"interpreter":{"hash":"c93591c313a95c8a89c667763bfd86bbb342a6e2dd3e91f10558630342cde4f4"}}},"nbformat":4,"nbformat_minor":0}
